--------------------------------------
User:


Est ce que tu connais un client bittorent qui sait sauvegarder les fichiers .torrent dans des répertoires qui correspondent aux catégories assigné au fichier de téléchargement. 
--------------------------------------
ChatGPT:


Oui — plusieurs clients le proposent, mais les deux plus simples et fiables pour ça sont qBittorrent et Deluge. Voici un résumé + comment les configurer rapidement, et quelques alternatives.

qBittorrent — simple et natif

qBittorrent propose un système de Catégories (labels) et permet de définir un Save path par catégorie : quand tu crées une catégorie tu peux indiquer un sous-dossier (il utilise le Default Save Path comme racine). Voir l’explication dans la doc/tuto. 
trash-guides.info

Étapes rapides :

Préférences → « Saving Management » → définir Default save path.

Dans la colonne « Categories » → clic droit → « Add category » → donne un nom et, si besoin, un Save path (sous-dossier).

Lors de l’ajout via Sonarr/Radarr ou manuellement, passe la catégorie souhaitée ; qBittorrent enregistrera le téléchargement dans le dossier lié à cette catégorie.

Note : quelques utilisateurs signalent des bugs/limitations avec l’interface WebUI pour le chemin par catégorie dans certaines versions — mais en général la fonctionnalité existe. 
GitHub
+1

Deluge — très configurable via plugins

Deluge nativement + plugins (AutoAdd, Categorise / Labels) permet d’assigner une étiquette et de déplacer automatiquement les torrents complétés vers des dossiers spécifiques. Le plugin Categorise ou Labels + AutoAdd est souvent utilisé pour obtenir exactement ce comportement. 
deluge-torrent.org
+2
deluge-torrent.org
+2

Étapes rapides :

Installer Deluge.

Activer/installer les plugins AutoAdd (pour dossiers « watch ») et Categorise/Labels.

Configurer les règles : label → dossier de destination. Les torrents ajoutés avec ce label seront sauvegardés dans le répertoire associé.

rTorrent / ruTorrent — puissant mais scripté

rTorrent/ruTorrent peut trier par label et déplacer via scripts (autolabel/autosort). Plus adapté aux serveurs/seedboxes si tu es à l’aise avec la conf et les scripts. 
Unix & Linux Stack Exchange
+1

Transmission — limité pour ça

Transmission garde généralement les .torrent dans son dossier de config et ne propose pas nativement de chemin différent par catégorie comme qBittorrent/Deluge. On voit des contournements via scripts externes après complétion. 
Ask Ubuntu
+1

Si tu veux, je peux :

Te donner les étapes exactes pour qBittorrent (avec captures de menus) ou pour Deluge (liste précise des plugins + config) selon celui que tu veux utiliser.

Ou te fournir un petit script (bash) qui, s’il détecte des torrents complétés, les déplace selon leur catégorie (utile si tu préfères Transmission ou rTorrent).

Laquelle préfères-tu ?
--------------------------------------
User:


Un script pour qbittorent c'est possible ? 
--------------------------------------
ChatGPT:


Oui 👍 c’est possible pour qBittorrent, même si lui-même ne propose pas directement de “sauvegarder les .torrent classés par catégorie”.

👉 L’idée : utiliser l’API Web de qBittorrent pour interroger régulièrement les torrents, récupérer leur catégorie et ensuite déplacer le .torrent correspondant vers un dossier qui porte le nom de cette catégorie.

Voici un exemple de script bash (Linux) qui fait ça :

bash
Copier le code
#!/bin/bash

# CONFIG
QBT_HOST="http://127.0.0.1:8080"   # Adresse du WebUI
QBT_USER="admin"                   # Utilisateur WebUI
QBT_PASS="motdepasse"              # Mot de passe WebUI
TORRENT_DIR="$HOME/qbittorrent/torrents"  # Dossier où qBittorrent sauvegarde les .torrent
DEST_DIR="$HOME/qbittorrent/by_category"  # Racine où ranger les .torrent par catégorie

COOKIE_FILE="/tmp/qbt_cookie.txt"

# Connexion et récupération du cookie de session
curl -s -c "$COOKIE_FILE" \
     -d "username=$QBT_USER&password=$QBT_PASS" \
     "$QBT_HOST/api/v2/auth/login" >/dev/null

# Récupérer la liste des torrents (hash + nom + catégorie)
torrents=$(curl -s -b "$COOKIE_FILE" "$QBT_HOST/api/v2/torrents/info")

# Boucle sur chaque torrent
echo "$torrents" | jq -c '.[]' | while read -r torrent; do
    hash=$(echo "$torrent" | jq -r '.hash')
    name=$(echo "$torrent" | jq -r '.name')
    category=$(echo "$torrent" | jq -r '.category')

    # Si pas de catégorie -> ignorer
    [ -z "$category" ] && continue

    # Dossier de destination
    mkdir -p "$DEST_DIR/$category"

    # Emplacement du .torrent dans qBittorrent
    src="$TORRENT_DIR/$hash.torrent"
    if [ -f "$src" ]; then
        cp "$src" "$DEST_DIR/$category/${name}.torrent"
        echo "Copié: $name -> $DEST_DIR/$category/"
    fi
done

⚙️ Prérequis

jq installé (sudo apt install jq) pour parser le JSON.

Tu dois connaître le dossier où qBittorrent sauvegarde les fichiers .torrent (dans ~/.local/share/data/qBittorrent/BT_backup/ sous Linux par défaut). Mets ce chemin dans TORRENT_DIR.

Tu dois activer l’API WebUI dans qBittorrent (Préférences → WebUI).

🔁 Automatisation

Sauvegarde le script, rends-le exécutable (chmod +x tri_torrents.sh).

Ajoute une tâche cron, par exemple toutes les 10 minutes :

bash
Copier le code
*/10 * * * * /chemin/vers/tri_torrents.sh


Veux-tu que je t’adapte le script exactement pour ton installation Linux, avec le bon chemin par défaut de BT_backup de qBittorrent ?
--------------------------------------
User:


Est ce que ce script est exécutable en auto une fois le téléchargement terminé ? 
--------------------------------------
ChatGPT:


Bonne question 👌

qBittorrent n’a pas (encore) de système de « hook » très riche, mais il a une option qui peut servir exactement à ça :

🔹 Fonction intégrée de qBittorrent

Dans Préférences → Téléchargements → Exécuter un programme externe après la fin du téléchargement, tu peux mettre le chemin d’un script.

qBittorrent appelle ce script à chaque fois qu’un torrent est terminé.

Il remplace des variables par des infos utiles :

%F → chemin complet du répertoire de destination

%N → nom du torrent

%L → catégorie/label du torrent

%R → racine (utile si multi-fichiers)

%I → hash info du torrent

👉 Donc tu pourrais directement t’appuyer sur %L (catégorie) pour ranger le .torrent du torrent terminé dans le bon dossier.

🔹 Exemple simple de script déclenché automatiquement
bash
Copier le code
#!/bin/bash
# Script appelé par qBittorrent quand un torrent est fini
# Arguments transmis par qBittorrent : %I = hash, %N = nom, %L = catégorie

HASH="$1"
NAME="$2"
CATEGORY="$3"

TORRENT_SRC="$HOME/.local/share/data/qBittorrent/BT_backup/${HASH}.torrent"
DEST_DIR="$HOME/qbittorrent/by_category/${CATEGORY}"

mkdir -p "$DEST_DIR"

if [ -f "$TORRENT_SRC" ]; then
    cp "$TORRENT_SRC" "$DEST_DIR/${NAME}.torrent"
    echo "$(date): $NAME copié vers $DEST_DIR" >> "$HOME/qbittorrent/torrent_sort.log"
fi


Puis, dans qBittorrent → Préférences → Téléchargements → Run external program, tu mets par exemple :

bash
Copier le code
/chemin/vers/mon_script.sh "%I" "%N" "%L"


✅ Résultat : ton script est exécuté automatiquement dès qu’un torrent est fini, et le .torrent est classé selon sa catégorie.

Veux-tu que je t’écrive la version prête à l’emploi avec les bons chemins pour Linux (ex. Debian/Ubuntu, dossier BT_backup) ?
--------------------------------------
User:


Oui, mais mon qbitorrent tourne dans un container docker 
--------------------------------------
ChatGPT:


Parfait 👍 merci pour la précision.
Quand qBittorrent tourne en Docker, il y a 2 points à bien comprendre :

Chemins internes au conteneur

L’option « Exécuter un programme externe » dans qBittorrent lance le script à l’intérieur du conteneur, pas sur ta machine hôte.

Donc si tu veux que le script touche les fichiers .torrent (dans BT_backup), il doit exister dans le conteneur et être exécutable.

Montages volumes

En général, tu montes ~/.local/share/qBittorrent (ou un dossier personnalisé) dans un volume Docker.

Exemple :

yaml
Copier le code
volumes:
  - /srv/qbittorrent/config:/config
  - /srv/qbittorrent/downloads:/downloads


Dans ce cas, les .torrent se trouvent dans /config/BT_backup dans le conteneur, et physiquement sur l’hôte dans /srv/qbittorrent/config/BT_backup.

🔹 Exemple de script pour Docker

Tu places ce script dans /config/scripts/ (monté depuis ton hôte).

bash
Copier le code
#!/bin/bash
# Script appelé par qBittorrent dans Docker quand un torrent est fini
# Arguments: %I = hash, %N = nom, %L = catégorie

HASH="$1"
NAME="$2"
CATEGORY="$3"

TORRENT_SRC="/config/BT_backup/${HASH}.torrent"
DEST_DIR="/config/torrents_by_category/${CATEGORY}"

mkdir -p "$DEST_DIR"

if [ -f "$TORRENT_SRC" ]; then
    cp "$TORRENT_SRC" "$DEST_DIR/${NAME}.torrent"
    echo "$(date): $NAME copié vers $DEST_DIR" >> "/config/torrent_sort.log"
fi


Ensuite :

chmod +x /srv/qbittorrent/config/scripts/sort_torrent.sh (sur l’hôte).

Dans l’interface qBittorrent → Préférences → Téléchargements → Exécuter un programme externe :

perl
Copier le code
/config/scripts/sort_torrent.sh "%I" "%N" "%L"


À chaque torrent complété, le .torrent est copié dans /config/torrents_by_category/<nom_catégorie>/.

👉 Question : tu veux que le classement se fasse uniquement dans le conteneur (donc dossiers accessibles via /config/...), ou tu veux que le script classe les .torrent directement sur ton hôte (ex. /srv/qbittorrent/torrents_by_category/), quitte à utiliser un docker exec depuis l’extérieur ?
--------------------------------------
User:


Explique moi la différence s'il te plaît 
--------------------------------------
ChatGPT:


Très bonne question 👌 je t’explique la différence entre les deux approches :

1. Script exécuté dans le conteneur (solution la plus simple)

qBittorrent lance le script depuis l’intérieur du conteneur.

Les chemins (/config/BT_backup, /config/torrents_by_category) sont ceux du conteneur.

Mais comme ton docker-compose ou ton docker run a sûrement un volume monté comme ceci :

yaml
Copier le code
volumes:
  - /srv/qbittorrent/config:/config


➝ tout ce que le script écrit dans /config/... (dans le conteneur) se retrouve physiquement dans /srv/qbittorrent/config/... (sur ton hôte).

Avantages :

Plus simple, car qBittorrent sait lancer le script directement.

Pas besoin de docker exec ni de cron externe.

Inconvénients :

Le script ne voit que ce qui est monté dans le conteneur (par ex. /config et /downloads).

Tu dois écrire le script en pensant aux chemins internes du conteneur.

2. Script exécuté sur l’hôte (machine)

qBittorrent tourne dans Docker, donc il ne peut pas exécuter directement ton script sur l’hôte.

Tu dois utiliser un docker exec ou surveiller les .torrent depuis l’hôte.

Exemple : un cron job qui fait :

bash
Copier le code
docker exec qbittorrent /config/scripts/sort_torrent.sh


Avantages :

Tu gardes le contrôle directement sur ton hôte.

Tu peux déplacer/copier les .torrent n’importe où sur ton système, pas seulement dans /srv/qbittorrent/config.

Inconvénients :

Plus compliqué à mettre en place (cron ou inotify externe).

Pas déclenché immédiatement à la fin d’un téléchargement, sauf si tu rajoutes un système de hook externe.

🏁 Conclusion

Si ton but c’est juste classer les .torrent dans des sous-dossiers par catégorie et les avoir dispo sur ton disque hôte ➝ solution 1 (dans le conteneur) est parfaite, et c’est ce que je t’ai préparé dans le script /config/scripts/sort_torrent.sh.

Si tu veux que ces .torrent soient déplacés dans un chemin de l’hôte complètement hors de /srv/qbittorrent/config (ex : /home/user/torrents_sorted), alors on passe en solution 2 avec un script qui tourne sur l’hôte.

👉 Tu veux que je t’écrive aussi la version solution 2 (sur l’hôte) pour que tu compares concrètement ?
--------------------------------------
User:


Non je reste sur la solution 1. 
--------------------------------------
ChatGPT:


Parfait 👍 tu as choisi la voie la plus simple et la plus fiable dans ton cas.

Donc pour résumer ta solution 1 :

Dans ton docker-compose ou ton docker run tu as sûrement :

yaml
Copier le code
volumes:
  - /srv/qbittorrent/config:/config


➝ tout ce qui se trouve dans /config dans le conteneur correspond à /srv/qbittorrent/config sur ton hôte.

Création du script dans le conteneur (par ex. /config/scripts/sort_torrent.sh) :

bash
Copier le code
#!/bin/bash
# Script lancé automatiquement par qBittorrent après téléchargement terminé
# %I = hash, %N = nom, %L = catégorie

HASH="$1"
NAME="$2"
CATEGORY="$3"

TORRENT_SRC="/config/BT_backup/${HASH}.torrent"
DEST_DIR="/config/torrents_by_category/${CATEGORY}"

mkdir -p "$DEST_DIR"

if [ -f "$TORRENT_SRC" ]; then
    cp "$TORRENT_SRC" "$DEST_DIR/${NAME}.torrent"
    echo "$(date): $NAME copié vers $DEST_DIR" >> "/config/torrent_sort.log"
fi


Le rendre exécutable (depuis l’hôte) :

bash
Copier le code
chmod +x /srv/qbittorrent/config/scripts/sort_torrent.sh


Configurer qBittorrent (dans l’UI Web) :

Aller dans Préférences → Téléchargements → Exécuter un programme externe après la fin du téléchargement.

Mettre :

perl
Copier le code
/config/scripts/sort_torrent.sh "%I" "%N" "%L"


À chaque torrent complété :

Le script est exécuté dans le conteneur.

Le .torrent est copié dans /config/torrents_by_category/<catégorie>/.

Sur ton hôte, tu retrouveras ça dans /srv/qbittorrent/config/torrents_by_category/<catégorie>/.

👉 Tu veux que je t’ajoute aussi une petite option pour que les .torrent soient déplacés (au lieu de copiés) afin de vider BT_backup, ou tu préfères garder la copie de sécurité ?
--------------------------------------
User:


Déplacé c'est bien oui 
--------------------------------------
ChatGPT:


Parfait 👍 dans ce cas, on modifie simplement le script pour faire un mv au lieu d’un cp.
Ainsi, chaque .torrent quitte BT_backup pour aller directement dans son dossier de catégorie.

🚀 Script mis à jour
bash
Copier le code
#!/bin/bash
# Script lancé automatiquement par qBittorrent après téléchargement terminé
# %I = hash, %N = nom, %L = catégorie

HASH="$1"
NAME="$2"
CATEGORY="$3"

TORRENT_SRC="/config/BT_backup/${HASH}.torrent"
DEST_DIR="/config/torrents_by_category/${CATEGORY}"

mkdir -p "$DEST_DIR"

if [ -f "$TORRENT_SRC" ]; then
    mv "$TORRENT_SRC" "$DEST_DIR/${NAME}.torrent"
    echo "$(date): $NAME déplacé vers $DEST_DIR" >> "/config/torrent_sort.log"
fi

⚠️ Remarque importante

Comme tu déplaces le .torrent hors de BT_backup, qBittorrent ne pourra plus le recharger si tu supprimes le torrent de la liste et que tu veux le réajouter.

Si tu veux à la fois ranger et garder une sauvegarde dans BT_backup, il vaut mieux rester sur la version avec cp.

👉 Tu veux que je t’ajoute une option pour garder une copie de secours compressée (genre .tar.gz dans un dossier backup), ou tu veux vraiment que ça sorte complètement de BT_backup ?
--------------------------------------
User:


À non on va garder une copie finalement 
--------------------------------------
ChatGPT:


Parfait 👍 dans ce cas on reste sur la version avec cp pour classer les .torrent par catégorie tout en gardant l’original dans BT_backup.

Voici la version finale recommandée :

bash
Copier le code
#!/bin/bash
# Script lancé automatiquement par qBittorrent après téléchargement terminé
# %I = hash, %N = nom, %L = catégorie

HASH="$1"
NAME="$2"
CATEGORY="$3"

TORRENT_SRC="/config/BT_backup/${HASH}.torrent"
DEST_DIR="/config/torrents_by_category/${CATEGORY}"

mkdir -p "$DEST_DIR"

if [ -f "$TORRENT_SRC" ]; then
    cp "$TORRENT_SRC" "$DEST_DIR/${NAME}.torrent"
    echo "$(date): $NAME copié vers $DEST_DIR" >> "/config/torrent_sort.log"
fi

✅ Avantages de garder une copie

qBittorrent continue de fonctionner normalement (il garde son .torrent dans BT_backup).

Tu as en plus une arborescence claire par catégorie pour tes archives.

En cas de problème ou de suppression par erreur, tu as toujours l’original intact.

👉 Veux-tu que je t’ajoute une rotation des logs dans ce script (ex : garder le fichier torrent_sort.log sous 1 Mo maximum), ou tu préfères un log simple qui grossit indéfiniment ?
--------------------------------------
User:


Va pour la rotation 
--------------------------------------
ChatGPT:


Super 👍 allons-y avec une rotation de log simple et efficace.
L’idée : dès que le log dépasse une certaine taille (ex. 1 Mo), on l’archive et on recommence un nouveau fichier.

🔹 Script avec rotation intégrée
bash
Copier le code
#!/bin/bash
# Script lancé automatiquement par qBittorrent après téléchargement terminé
# %I = hash, %N = nom, %L = catégorie

HASH="$1"
NAME="$2"
CATEGORY="$3"

TORRENT_SRC="/config/BT_backup/${HASH}.torrent"
DEST_DIR="/config/torrents_by_category/${CATEGORY}"
LOG_FILE="/config/torrent_sort.log"
MAX_SIZE=1048576   # 1 Mo en octets

mkdir -p "$DEST_DIR"

if [ -f "$TORRENT_SRC" ]; then
    cp "$TORRENT_SRC" "$DEST_DIR/${NAME}.torrent"
    echo "$(date): $NAME copié vers $DEST_DIR" >> "$LOG_FILE"
fi

# Rotation du log si > 1 Mo
if [ -f "$LOG_FILE" ]; then
    FILE_SIZE=$(stat -c%s "$LOG_FILE")
    if [ "$FILE_SIZE" -gt "$MAX_SIZE" ]; then
        TIMESTAMP=$(date +%Y%m%d-%H%M%S)
        mv "$LOG_FILE" "/config/torrent_sort_$TIMESTAMP.log"
        echo "$(date): Nouveau log démarré (ancien archivé en torrent_sort_$TIMESTAMP.log)" > "$LOG_FILE"
    fi
fi

🔹 Résultat

Le script fait toujours la copie du .torrent dans le bon dossier de catégorie.

Le fichier de log /config/torrent_sort.log garde une trace des actions.

Quand il dépasse 1 Mo, il est renommé en /config/torrent_sort_YYYYMMDD-HHMMSS.log, et un nouveau log est créé automatiquement.

👉 Tu veux que je pousse encore plus loin et que le vieux log soit compressé en .gz pour gagner de la place, ou tu préfères juste garder les fichiers bruts ?
--------------------------------------
User:


Non je veux que le vieux log soit supprimé 
--------------------------------------
ChatGPT:


Parfait 👍 on va faire encore plus simple : dès que le log atteint 1 Mo, on l’écrase et on repart de zéro (donc pas d’archives, pas de compression).

🔹 Script final avec suppression du vieux log
bash
Copier le code
#!/bin/bash
# Script lancé automatiquement par qBittorrent après téléchargement terminé
# %I = hash, %N = nom, %L = catégorie

HASH="$1"
NAME="$2"
CATEGORY="$3"

TORRENT_SRC="/config/BT_backup/${HASH}.torrent"
DEST_DIR="/config/torrents_by_category/${CATEGORY}"
LOG_FILE="/config/torrent_sort.log"
MAX_SIZE=1048576   # 1 Mo en octets

mkdir -p "$DEST_DIR"

if [ -f "$TORRENT_SRC" ]; then
    cp "$TORRENT_SRC" "$DEST_DIR/${NAME}.torrent"
    echo "$(date): $NAME copié vers $DEST_DIR" >> "$LOG_FILE"
fi

# Rotation du log si > 1 Mo
if [ -f "$LOG_FILE" ]; then
    FILE_SIZE=$(stat -c%s "$LOG_FILE")
    if [ "$FILE_SIZE" -gt "$MAX_SIZE" ]; then
        rm "$LOG_FILE"
        echo "$(date): Nouveau log démarré (ancien supprimé)" > "$LOG_FILE"
    fi
fi

🔹 Ce qui va se passer

Le log enregistre normalement chaque action.

Dès qu’il dépasse 1 Mo, il est supprimé et un nouveau fichier est créé automatiquement.

👉 Tu veux que je fixe la taille max à 1 Mo pile, ou tu préfères une limite plus petite (par ex. 100 Ko) pour que ça tourne court et léger ?
--------------------------------------
User:


est-ce que tu peux me paramétrer le script avec comme nom de catégorie hum
--------------------------------------
ChatGPT:


Oui, je peux le faire 🙂

Pour clarifier : tu veux que tous les .torrent copiés aillent dans un dossier unique nommé hum, au lieu de créer un dossier par catégorie %L, c’est bien ça ?
--------------------------------------
User:


seulment pour les torrents qui dépendent de la catégorie hum
--------------------------------------
ChatGPT:


Parfait, je comprends ✅

On va modifier le script pour qu’il ne copie les .torrent que si la catégorie du torrent est hum. Les autres torrents seront ignorés.

🔹 Script final filtré sur la catégorie hum
bash
Copier le code
#!/bin/bash
# Script lancé automatiquement par qBittorrent après téléchargement terminé
# %I = hash, %N = nom, %L = catégorie

HASH="$1"
NAME="$2"
CATEGORY="$3"

# Ne traiter que les torrents dont la catégorie est "hum"
if [ "$CATEGORY" != "hum" ]; then
    exit 0
fi

TORRENT_SRC="/config/BT_backup/${HASH}.torrent"
DEST_DIR="/config/torrents_by_category/hum"
LOG_FILE="/config/torrent_sort.log"
MAX_SIZE=1048576   # 1 Mo en octets

mkdir -p "$DEST_DIR"

if [ -f "$TORRENT_SRC" ]; then
    cp "$TORRENT_SRC" "$DEST_DIR/${NAME}.torrent"
    echo "$(date): $NAME copié vers $DEST_DIR" >> "$LOG_FILE"
fi

# Rotation du log si > 1 Mo
if [ -f "$LOG_FILE" ]; then
    FILE_SIZE=$(stat -c%s "$LOG_FILE")
    if [ "$FILE_SIZE" -gt "$MAX_SIZE" ]; then
        rm "$LOG_FILE"
        echo "$(date): Nouveau log démarré (ancien supprimé)" > "$LOG_FILE"
    fi
fi


✅ Ce que fait ce script maintenant :

Ne s’active que si la catégorie du torrent est hum.

Copie le .torrent dans /config/torrents_by_category/hum.

Gère le log avec suppression automatique si > 1 Mo.

Si tu veux, je peux te proposer une version qui supporte plusieurs catégories spécifiques (par exemple hum et bio), sans avoir à modifier le script à chaque fois.

Veux‑tu que je fasse ça ?
--------------------------------------
User:


est-ce que tu peux modifier le scipt pour que les fichiers .torrent ciblé soient copier dans le répertoire hum_torrent ?
--------------------------------------
ChatGPT:


Bien sûr ✅, on va simplement changer le dossier de destination pour qu’il soit /config/hum_torrent au lieu de /config/torrents_by_category/hum.

Voici le script mis à jour :

🔹 Script pour copier les .torrent de la catégorie hum dans hum_torrent
bash
Copier le code
#!/bin/bash
# Script lancé automatiquement par qBittorrent après téléchargement terminé
# %I = hash, %N = nom, %L = catégorie

HASH="$1"
NAME="$2"
CATEGORY="$3"

# Ne traiter que les torrents dont la catégorie est "hum"
if [ "$CATEGORY" != "hum" ]; then
    exit 0
fi

TORRENT_SRC="/config/BT_backup/${HASH}.torrent"
DEST_DIR="/config/hum_torrent"
LOG_FILE="/config/torrent_sort.log"
MAX_SIZE=1048576   # 1 Mo en octets

mkdir -p "$DEST_DIR"

if [ -f "$TORRENT_SRC" ]; then
    cp "$TORRENT_SRC" "$DEST_DIR/${NAME}.torrent"
    echo "$(date): $NAME copié vers $DEST_DIR" >> "$LOG_FILE"
fi

# Rotation du log si > 1 Mo
if [ -f "$LOG_FILE" ]; then
    FILE_SIZE=$(stat -c%s "$LOG_FILE")
    if [ "$FILE_SIZE" -gt "$MAX_SIZE" ]; then
        rm "$LOG_FILE"
        echo "$(date): Nouveau log démarré (ancien supprimé)" > "$LOG_FILE"
    fi
fi


✅ Résultat attendu :

Seuls les torrents de catégorie hum sont traités.

Les fichiers .torrent correspondants sont copiés dans /config/hum_torrent.

Le log est géré avec rotation automatique (> 1 Mo).

Si tu veux, je peux te faire une version encore plus flexible où tu pourrais facilement changer le nom du répertoire et la catégorie à surveiller sans toucher au script. Veux‑tu que je fasse ça ?
--------------------------------------
User:


oui
--------------------------------------
ChatGPT:


Parfait 😄 on va rendre le script paramétrable, de manière à ce que tu puisses changer :

La catégorie ciblée (CATEGORY_TARGET)

Le répertoire de destination (DEST_DIR)

sans toucher au reste du code.

🔹 Script paramétrable
bash
Copier le code
#!/bin/bash
# Script lancé automatiquement par qBittorrent après téléchargement terminé
# %I = hash, %N = nom, %L = catégorie

# ---------------- Paramètres ----------------
CATEGORY_TARGET="hum"                # Catégorie à surveiller
DEST_DIR="/config/hum_torrent"      # Répertoire où copier les .torrent
LOG_FILE="/config/torrent_sort.log" # Fichier de log
MAX_SIZE=1048576                     # Taille max du log en octets (1 Mo)
# -------------------------------------------

HASH="$1"
NAME="$2"
CATEGORY="$3"

# Ne traiter que les torrents de la catégorie cible
if [ "$CATEGORY" != "$CATEGORY_TARGET" ]; then
    exit 0
fi

TORRENT_SRC="/config/BT_backup/${HASH}.torrent"

mkdir -p "$DEST_DIR"

if [ -f "$TORRENT_SRC" ]; then
    cp "$TORRENT_SRC" "$DEST_DIR/${NAME}.torrent"
    echo "$(date): $NAME copié vers $DEST_DIR" >> "$LOG_FILE"
fi

# Rotation du log si > MAX_SIZE
if [ -f "$LOG_FILE" ]; then
    FILE_SIZE=$(stat -c%s "$LOG_FILE")
    if [ "$FILE_SIZE" -gt "$MAX_SIZE" ]; then
        rm "$LOG_FILE"
        echo "$(date): Nouveau log démarré (ancien supprimé)" > "$LOG_FILE"
    fi
fi

🔹 Avantages de cette version

Tu peux changer CATEGORY_TARGET et DEST_DIR sans modifier le reste du script.

Fonctionne toujours avec qBittorrent dans Docker.

Log géré automatiquement (>1 Mo, suppression du vieux log).

Si tu veux, je peux te proposer une petite version qui accepte plusieurs catégories à la fois et copie les .torrent dans des dossiers distincts automatiquement.
Veux‑tu que je fasse ça ?
--------------------------------------
User:


oui
--------------------------------------
ChatGPT:


Parfait 😄 on va créer une version qui :

Accepte plusieurs catégories à la fois (ex. hum, bio, tech).

Copie chaque .torrent dans un dossier dédié, par exemple /config/hum_torrent, /config/bio_torrent, etc.

Gère toujours le log avec rotation (>1 Mo, suppression du vieux log).

🔹 Script multi-catégories
bash
Copier le code
#!/bin/bash
# Script lancé automatiquement par qBittorrent après téléchargement terminé
# %I = hash, %N = nom, %L = catégorie

# ---------------- Paramètres ----------------
# Liste des catégories à surveiller
declare -A CATEGORY_DIRS=(
    ["hum"]="/config/hum_torrent"
    ["bio"]="/config/bio_torrent"
    ["tech"]="/config/tech_torrent"
)

LOG_FILE="/config/torrent_sort.log" # Fichier de log
MAX_SIZE=1048576                     # Taille max du log en octets (1 Mo)
# -------------------------------------------

HASH="$1"
NAME="$2"
CATEGORY="$3"

# Vérifier si la catégorie du torrent est dans la liste
DEST_DIR="${CATEGORY_DIRS[$CATEGORY]}"

if [ -z "$DEST_DIR" ]; then
    # Catégorie non ciblée, ne rien faire
    exit 0
fi

TORRENT_SRC="/config/BT_backup/${HASH}.torrent"
mkdir -p "$DEST_DIR"

if [ -f "$TORRENT_SRC" ]; then
    cp "$TORRENT_SRC" "$DEST_DIR/${NAME}.torrent"
    echo "$(date): $NAME copié vers $DEST_DIR" >> "$LOG_FILE"
fi

# Rotation du log si > MAX_SIZE
if [ -f "$LOG_FILE" ]; then
    FILE_SIZE=$(stat -c%s "$LOG_FILE")
    if [ "$FILE_SIZE" -gt "$MAX_SIZE" ]; then
        rm "$LOG_FILE"
        echo "$(date): Nouveau log démarré (ancien supprimé)" > "$LOG_FILE"
    fi
fi

🔹 Ce que fait ce script

Les .torrent sont copiés uniquement si leur catégorie est dans CATEGORY_DIRS.

Chaque catégorie a son propre dossier de destination.

Le log est conservé jusqu’à 1 Mo, puis supprimé et redémarré.

Facile à modifier : tu ajoutes simplement une ligne dans CATEGORY_DIRS pour chaque nouvelle catégorie.

Si tu veux, je peux te proposer une variante encore plus flexible, où tu n’as besoin que de la catégorie et le script crée automatiquement un dossier <catégorie>_torrent sans avoir à remplir le tableau à la main.
Veux‑tu que je fasse ça ?
--------------------------------------
User:


oui
--------------------------------------
ChatGPT:


Parfait 😄 on peut rendre le script auto‑configurable :

Tu n’as plus besoin de remplir un tableau pour chaque catégorie.

Dès qu’un torrent a une catégorie ciblée (ex. hum), le script crée automatiquement un dossier <catégorie>_torrent et y copie le .torrent.

La rotation du log reste active (>1 Mo, suppression du vieux log).

🔹 Script automatique par catégorie
bash
Copier le code
#!/bin/bash
# Script lancé automatiquement par qBittorrent après téléchargement terminé
# %I = hash, %N = nom, %L = catégorie

# ---------------- Paramètres ----------------
# Liste des catégories à surveiller (séparées par espace)
TARGET_CATEGORIES="hum bio tech"

LOG_FILE="/config/torrent_sort.log" # Fichier de log
MAX_SIZE=1048576                     # Taille max du log en octets (1 Mo)
# -------------------------------------------

HASH="$1"
NAME="$2"
CATEGORY="$3"

# Vérifier si la catégorie du torrent est dans la liste
if ! [[ " $TARGET_CATEGORIES " =~ " $CATEGORY " ]]; then
    exit 0
fi

# Créer automatiquement le dossier <categorie>_torrent
DEST_DIR="/config/${CATEGORY}_torrent"
TORRENT_SRC="/config/BT_backup/${HASH}.torrent"

mkdir -p "$DEST_DIR"

if [ -f "$TORRENT_SRC" ]; then
    cp "$TORRENT_SRC" "$DEST_DIR/${NAME}.torrent"
    echo "$(date): $NAME copié vers $DEST_DIR" >> "$LOG_FILE"
fi

# Rotation du log si > MAX_SIZE
if [ -f "$LOG_FILE" ]; then
    FILE_SIZE=$(stat -c%s "$LOG_FILE")
    if [ "$FILE_SIZE" -gt "$MAX_SIZE" ]; then
        rm "$LOG_FILE"
        echo "$(date): Nouveau log démarré (ancien supprimé)" > "$LOG_FILE"
    fi
fi

🔹 Avantages de cette version

Tu peux ajouter ou supprimer des catégories à surveiller simplement en modifiant TARGET_CATEGORIES.

Chaque catégorie reçoit automatiquement son dossier <catégorie>_torrent.

Log géré automatiquement (>1 Mo, suppression du vieux log).

Plus besoin de modifier le code si tu veux ajouter de nouvelles catégories.

Si tu veux, je peux te proposer une variante encore plus “Docker-friendly”, qui fonctionne même si les noms de fichiers contiennent des espaces ou caractères spéciaux, pour que ça ne plante jamais dans ton conteneur.
Veux‑tu que je fasse ça ?
--------------------------------------
User:


oui
--------------------------------------
ChatGPT:


Parfait 😄 voici une version Docker-friendly et robuste :

Fonctionne même si le nom du torrent ou la catégorie contient des espaces ou caractères spéciaux.

Gère correctement les chemins avec espaces ou symboles.

Copie les .torrent dans <catégorie>_torrent.

Rotation du log (>1 Mo, suppression du vieux log) toujours active.

🔹 Script Docker-friendly
bash
Copier le code
#!/bin/bash
# Script lancé automatiquement par qBittorrent après téléchargement terminé
# %I = hash, %N = nom, %L = catégorie

# ---------------- Paramètres ----------------
TARGET_CATEGORIES="hum bio tech"
LOG_FILE="/config/torrent_sort.log"
MAX_SIZE=1048576   # 1 Mo
# -------------------------------------------

HASH="$1"
NAME="$2"
CATEGORY="$3"

# Vérifier si la catégorie est dans la liste
FOUND=0
for cat in $TARGET_CATEGORIES; do
    if [ "$cat" = "$CATEGORY" ]; then
        FOUND=1
        break
    fi
done

if [ "$FOUND" -eq 0 ]; then
    exit 0
fi

# Créer le dossier <categorie>_torrent de manière sûre
DEST_DIR="/config/${CATEGORY}_torrent"
TORRENT_SRC="/config/BT_backup/${HASH}.torrent"

mkdir -p "$DEST_DIR"

# Copier le .torrent en gérant correctement les espaces et caractères spéciaux
if [ -f "$TORRENT_SRC" ]; then
    cp -- "$TORRENT_SRC" "$DEST_DIR/${NAME}.torrent"
    echo "$(date '+%Y-%m-%d %H:%M:%S') : '$NAME' copié vers '$DEST_DIR'" >> "$LOG_FILE"
fi

# Rotation du log si > MAX_SIZE
if [ -f "$LOG_FILE" ]; then
    FILE_SIZE=$(stat -c%s "$LOG_FILE")
    if [ "$FILE_SIZE" -gt "$MAX_SIZE" ]; then
        rm "$LOG_FILE"
        echo "$(date '+%Y-%m-%d %H:%M:%S') : Nouveau log démarré (ancien supprimé)" > "$LOG_FILE"
    fi
fi

🔹 Points forts

✅ Sécurité totale pour noms de fichiers ou catégories avec espaces / caractères spéciaux.

✅ Multi-catégories gérées via TARGET_CATEGORIES.

✅ Création automatique des dossiers <catégorie>_torrent.

✅ Rotation de log simple et sûre (>1 Mo).

✅ Fonctionne directement dans un conteneur Docker.

Si tu veux, je peux te préparer un exemple complet de configuration WebUI qBittorrent + Docker avec ce script déjà placé dans le conteneur et prêt à être utilisé automatiquement après chaque téléchargement.

Veux‑tu que je fasse ça ?
--------------------------------------
User:


rappelle moi la ligne de commande à placer dans qbittorrent ?
--------------------------------------
ChatGPT:


Oui, bien sûr ✅

Dans qBittorrent → Préférences → Téléchargements → Exécuter un programme externe après la fin du téléchargement, tu dois mettre la ligne complète avec les variables de qBittorrent pour que le script reçoive les bons paramètres.

Avec notre script Docker-friendly, la ligne sera :

bash
Copier le code
/config/scripts/sort_torrent.sh "%I" "%N" "%L"

🔹 Explications des variables

%I → Hash du torrent

%N → Nom du torrent

%L → Catégorie/label du torrent

Le script les récupère dans cet ordre et décide si le .torrent doit être copié selon la catégorie.

💡 Astuce : assure-toi que le script est exécutable dans le conteneur :

bash
Copier le code
chmod +x /srv/qbittorrent/config/scripts/sort_torrent.sh


Après ça, chaque torrent terminé déclenchera automatiquement le script.

Veux‑tu que je te fasse un petit schéma du flux complet dans Docker pour visualiser comment ça fonctionne ?
--------------------------------------
User:


le script ne semble pas se lancer et pas de fichier de log non plus
--------------------------------------
ChatGPT:


Ah, ça arrive souvent dans Docker 😅 — la raison principale est que qBittorrent dans un conteneur lance le script à l’intérieur du conteneur, donc :

Le script doit être présent dans le conteneur.

Le chemin que tu mets dans WebUI doit être celui du conteneur, pas de l’hôte.

Le script doit être exécutable dans le conteneur (chmod +x).

🔹 Étapes pour vérifier / corriger

Vérifie que le script est dans le conteneur

Si ton conteneur monte /srv/qbittorrent/config vers /config, alors depuis l’hôte :

bash
Copier le code
ls -l /srv/qbittorrent/config/scripts/


Tu devrais voir sort_torrent.sh.

Vérifie les permissions
Dans l’hôte ou dans le conteneur :

bash
Copier le code
chmod +x /srv/qbittorrent/config/scripts/sort_torrent.sh


Vérifie que le chemin dans WebUI est correct
Dans le conteneur, le script est accessible via /config/scripts/sort_torrent.sh. Donc dans qBittorrent :

bash
Copier le code
/config/scripts/sort_torrent.sh "%I" "%N" "%L"


Tester le script manuellement dans le conteneur
Pour t’assurer qu’il fonctionne :

bash
Copier le code
docker exec -it <nom_du_conteneur> bash
/config/scripts/sort_torrent.sh "FAKEHASH" "Test Torrent" "hum"


Vérifie si le fichier est copié dans /config/hum_torrent et si un log est créé.

Si ça fonctionne, alors le problème vient de la liaison WebUI → script.

Vérifie que la WebUI a bien activé l’option
Dans qBittorrent :

Préférences → Téléchargements → “Exécuter un programme externe après la fin du téléchargement” cochez la case et assurez-vous que la ligne de commande est exactement celle-ci :

bash
Copier le code
/config/scripts/sort_torrent.sh "%I" "%N" "%L"


💡 Astuce Docker spécifique : certains conteneurs limitent l’accès au shell ou aux scripts.
Si le script n’est pas exécuté malgré tout, on peut ajouter une ligne de debug au début du script pour écrire systématiquement dans /config/torrent_sort.log et voir s’il est appelé :

bash
Copier le code
echo "$(date) : Script appelé avec HASH='$1', NAME='$2', CATEGORY='$3'" >> /config/torrent_sort.log


Si tu veux, je peux te préparer une version du script avec debug activé pour Docker, qui permet de voir exactement pourquoi il ne se lance pas.
Veux‑tu que je fasse ça ?
--------------------------------------
